Table des matières
lldap : annuaire des utilisateurs
Structure de répertoire lldap dockerisée
lldap Docker Composer le fichier
Fichier lldap conteneur-vars.env
Fichier de configuration lldap TOML
lldap Chiffrons le certificat via Caddy
Recharger la configuration de Caddy
Configuration utilisateur lldap via l'interface utilisateur
Compte Sendgrid gratuit pour envoyer des e-mails depuis votre serveur
Redis : stockage de session persistant
Structure de répertoire Redis dockerisée
Fichier de composition Redis Docker
Authelia : authentification et autorisation des utilisateurs
Structure de répertoire Authelia dockerisée
Fichier de composition Authelia Docker
Fichier Authelia conteneur-vars.env
Fichier de configuration Authelia YAML
Démarrer le conteneur Authelia
Certificat Authelia Let's Encrypt via Caddy
Recharger la configuration de Caddy
Ajouter un point de terminaison protégé à Authelia via Caddy
Configuration mise à jour pour Authelia 4.38
Cet article explique comment mettre en place un système simple mais moderne de gestion des utilisateurs et d'authentification pour les services de votre réseau domestique interne. La solution prend en charge des fonctionnalités de sécurité importantes telles que l'authentification à deux facteurs et l'authentification unique, et ne nécessite qu'une maintenance minimale grâce à la réinitialisation du mot de passe en libre-service. Cet article fait partie de ma série sur la domotique qui montre comment installer, configurer et exécuter un serveur domestique avec des services (dockerisés ou virtualisés) tels que Home Assistant et ownCloud.
Je suppose que vous avez configuré Docker et le conteneur Caddy comme décrit dans les articles précédents de cette série.
Light LDAP (lldap) est un serveur d'authentification LDAP léger doté d'une interface utilisateur Web conviviale qui vise à faciliter la gestion des utilisateurs. lldap est simple à configurer, est livré avec des « paramètres de base par défaut » et cible les serveurs auto-hébergés.
Voici à quoi ressemblera la structure des répertoires lorsque nous aurons terminé :
rpool/
└── encrypted/
└── docker/
└── lldap/
├── data/
└── lldap_config.toml
├── secrets/
├── JWT_SECRET
└── LDAP_USER_PASS
├── container-vars.env
└── docker-compose.yml
Nous plaçons la configuration sur l'ensemble de données ZFS chiffré ( rpool/encrypted) car il contient des secrets tels que des clés privées et des mots de passe.
Créez les répertoires :
mkdir -p /rpool/encrypted/docker/lldap/data
mkdir -p /rpool/encrypted/docker/lldap/secrets
Créez docker-compose.ymlavec le contenu suivant :
version: "3.9"
services:
lldap:
container_name: lldap
hostname: lldap
image: lldap/lldap:stable
restart: unless-stopped
networks:
- caddy_caddynet
expose:
- 3890 # LDAP
- 17170 # Web UI
env_file:
- container-vars.env
volumes:
- ./data:/data
- ./secrets:/secrets
networks:
caddy_caddynet:
external: true
Créez container-vars.env avec le contenu suivant :
LLDAP_LDAP_BASE_DN=dc=example,dc=com # replace with your domain
UID=0 # run as root
GID=0 # run as root
# Secrets: lldap reads them from the specified files.
# This way, the secrets are not part of any process' environment.
LLDAP_JWT_SECRET_FILE=/secrets/JWT_SECRET
LLDAP_LDAP_USER_PASS_FILE=/secrets/LDAP_USER_PASS
Générez des chaînes alphanumériques aléatoires et stockez-les dans des fichiers individuels du secretsrépertoire :
cd /rpool/encrypted/docker/lldap/
tr -cd '[:alnum:]' < /dev/urandom | fold -w "64" | head -n 1 > ./secrets/JWT_SECRET
tr -cd '[:alnum:]' < /dev/urandom | fold -w "20" | head -n 1 > ./secrets/LDAP_USER_PASS
Nous utilisons une version personnalisée du modèle de configuration de lldap . Créez data/lldap_config.tomlavec le contenu suivant :
database_url = "sqlite:///data/users.db?mode=rwc"
key_file = "/data/private_key"
enable_password_reset = false
Naviguez dans le répertoire avec docker-compose.ymlet exécutez :
docker compose up -d
Inspectez les journaux du conteneur pour détecter les erreurs avec la commande docker compose logs --tail 30 --timestamps.
Ajoutez ce qui suit à Caddyfile( détails ) :
lldap.{$MY_DOMAIN} {
reverse_proxy lldap:17170
tls {
dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
}
Ajoutez l'enregistrement A suivant à votre domaine DNS :
lldap.home.yourdomain.com 192.168.0.4 # replace with your Docker host's IP address
Essayez de résoudre le nom sur une machine de votre réseau (par exemple, nslookup lldap.home.yourdomain.com). Si cela échoue, vous devrez peut-être contourner la protection de rebind DNS sur votre routeur .
Demandez à Caddy de recharger sa configuration en exécutant :
docker exec -w /etc/caddy caddy caddy reload
Vous devriez maintenant pouvoir accéder à l'interface Web lldap https://lldap.home.yourdomain.comsans recevoir d'avertissement de certificat de votre navigateur.
Dans votre navigateur, ouvrez https://lldap.home.yourdomain.com. Connectez-vous avec l'utilisateur adminet le mot de passe stockés dans le fichier /secrets/LDAP_USER_PASS. Créez un nouvel utilisateur administrateur avec votre propre nom (par exemple, anne) en cliquant sur Créer un utilisateur et en remplissant le formulaire. Ajoutez ce compte utilisateur personnel au groupe lldap_admin.
Un service comme Authelia doit envoyer des e-mails, par exemple pour réinitialiser un mot de passe. Configurer votre propre serveur SMTP pour cette tâche n'est pas une très bonne idée : ces emails seraient marqués comme spam par toute application de messagerie qui se respecte.
Au lieu de cela, créez un compte gratuit sur Sendgrid (ou un service alternatif). Au moment de la rédaction de cet article, le forfait gratuit de Sendgrid vous permet d'envoyer 100 e-mails par jour, ce qui devrait être plus que suffisant pour un message occasionnel provenant de votre serveur domestique.
Lorsque vous créez votre compte Sendgrid, assurez-vous d'authentifier votre adresse d'envoi – ou, mieux encore, votre domaine d'envoi. L'adresse/domaine d'envoi est configuré via la variable d'environnement AUTHELIA_NOTIFIER_SMTP_SENDER(voir ci-dessous).
Redis est un magasin de données en mémoire qui peut être utilisé par Authelia comme fournisseur de stockage de session. En utilisant un service externe pour les données de session, Authelia peut être redémarré sans que les utilisateurs aient à se réauthentifier.
Voici à quoi ressemblera la structure des répertoires lorsque nous aurons terminé :
rpool/
└── encrypted/
└── docker/
└── redis/
├── data/
└── docker-compose.yml
Créez le répertoire :
mkdir -p /rpool/encrypted/docker/redis/data
Créez docker-compose.ymlavec le contenu suivant :
version: "3.9"
services:
redis:
container_name: redis
hostname: redis
image: redis:latest
restart: unless-stopped
networks:
- caddy_caddynet
expose:
- 6379
volumes:
- ./data:/data
networks:
caddy_caddynet:
external: true
Naviguez dans le répertoire avec docker-compose.ymlet exécutez :
docker compose up -d
Inspectez les journaux du conteneur pour détecter les erreurs avec la commande docker compose logs --tail 30 --timestamps. Ignorez l'avertissement qui recommande de définir vm.overcommit_memory = 1 sur l'hôte .
Authelia est un serveur léger de gestion des identités et des accès (IAM). Il fournit une authentification unique (SSO) et une authentification multifacteur (MFA) via un portail Web convivial. Authelia est généralement utilisé en conjonction avec des proxys inverses tels que Caddy.
Voici à quoi ressemblera la structure des répertoires lorsque nous aurons terminé :
rpool/
└── encrypted/
└── docker/
└── authelia/
├── config/
└── configuration.yml
├── secrets/
├── JWT_SECRET
├── SESSION_SECRET
├── STORAGE_ENCRYPTION_KEY
├── NOTIFIER_SMTP_PASSWORD
└── AUTHENTICATION_BACKEND_LDAP_PASSWORD
├── container-vars.env
└── docker-compose.yml
Nous plaçons la configuration sur l'ensemble de données ZFS chiffré ( rpool/encrypted) car il contient des secrets tels que des clés privées et des mots de passe.
Créez les répertoires :
mkdir -p /rpool/encrypted/docker/authelia/config
mkdir -p /rpool/encrypted/docker/authelia/secrets
Créez docker-compose.ymlavec le contenu suivant :
version: "3.9"
services:
authelia:
container_name: authelia
hostname: authelia
image: authelia/authelia:4
restart: unless-stopped
networks:
- caddy_caddynet
expose:
- 9091
env_file:
- container-vars.env
volumes:
- ./config:/config
- ./secrets:/secrets
networks:
caddy_caddynet:
external: true
Créez container-vars.envavec le contenu suivant :
AUTHELIA_SESSION_DOMAIN=home.yourdomain.com # replace with your domain
AUTHELIA_TOTP_ISSUER=home.yourdomain.com # replace with your domain
AUTHELIA_WEBAUTHN_DISPLAY_NAME=home # replace with name of your home
AUTHELIA_NOTIFIER_SMTP_ADDRESS=submission://smtp.sendgrid.net:587
AUTHELIA_NOTIFIER_SMTP_USERNAME=apikey # replace with your SMTP server's username
AUTHELIA_NOTIFIER_SMTP_SENDER="Your Name <name@domain.com>" # replace with your name/email
AUTHELIA_AUTHENTICATION_BACKEND_LDAP_ADDRESS=ldap://lldap:3890
AUTHELIA_AUTHENTICATION_BACKEND_LDAP_BASE_DN=dc=example,dc=com # must be identical to what is configured in lldap
AUTHELIA_AUTHENTICATION_BACKEND_LDAP_USER=uid=admin,ou=people,dc=example,dc=com # must be the DN of your admin configured in lldap
# Secrets: Authelia reads them from the specified files.
# This way, the secrets are not part of any process' environment.
AUTHELIA_IDENTITY_VALIDATION_RESET_PASSWORD_JWT_SECRET_FILE=/secrets/JWT_SECRET
AUTHELIA_SESSION_SECRET_FILE=/secrets/SESSION_SECRET
AUTHELIA_STORAGE_ENCRYPTION_KEY_FILE=/secrets/STORAGE_ENCRYPTION_KEY
AUTHELIA_NOTIFIER_SMTP_PASSWORD_FILE=/secrets/NOTIFIER_SMTP_PASSWORD
AUTHELIA_AUTHENTICATION_BACKEND_LDAP_PASSWORD_FILE=/secrets/AUTHENTICATION_BACKEND_LDAP_PASSWORD
Générez des chaînes alphanumériques aléatoires et stockez-les dans des fichiers individuels du secretsrépertoire :
cd /rpool/encrypted/docker/authelia/
tr -cd '[:alnum:]' < /dev/urandom | fold -w "64" | head -n 1 > ./secrets/JWT_SECRET
tr -cd '[:alnum:]' < /dev/urandom | fold -w "64" | head -n 1 > ./secrets/SESSION_SECRET
tr -cd '[:alnum:]' < /dev/urandom | fold -w "64" | head -n 1 > ./secrets/STORAGE_ENCRYPTION_KEY
Créez le fichier /secrets/NOTIFIER_SMTP_PASSWORDet collez-y le mot de passe de l'utilisateur de votre serveur SMTP.
Créez le fichier /secrets/AUTHENTICATION_BACKEND_LDAP_PASSWORDet collez- lldap/secrets/LDAP_USER_PASSy le mot de passe administrateur lldap.
Nous utilisons une version personnalisée du modèle de configuration d'Authelia . Créez config/configuration.ymlavec le contenu suivant :
---
theme: auto
default_2fa_method: totp
server:
address: tcp://0.0.0.0:9091/
log:
level: info
totp:
disable: false
algorithm: sha1
digits: 6
period: 30
skew: 1
secret_size: 32
webauthn:
disable: false
timeout: 60s
attestation_conveyance_preference: indirect
user_verification: preferred
authentication_backend:
password_reset:
disable: false
refresh_interval: 5m
ldap:
implementation: custom
timeout: 5s
start_tls: false
attributes:
username: uid
display_name: displayName
group_name: cn
mail: mail
additional_users_dn: ou=people
users_filter: "(&({username_attribute}={input})(objectClass=person))"
additional_groups_dn: ou=groups
groups_filter: "(member={dn})"
password_policy:
standard:
enabled: false
min_length: 8
max_length: 0
require_uppercase: true
require_lowercase: true
require_number: true
require_special: false
access_control:
default_policy: two_factor
session:
name: authelia_session
redis:
host: redis
port: 6379
regulation:
max_retries: 3
find_time: 2m
ban_time: 5m
storage:
local:
path: /config/db.sqlite3
notifier:
disable_startup_check: false
...
Naviguez dans le répertoire avec docker-compose.ymlet exécutez :
docker compose up -d
Inspectez les journaux du conteneur pour détecter les erreurs avec la commande docker compose logs --tail 30 --timestamps.
Ajoutez ce qui suit à Caddyfile( détails ) :
auth.{$MY_DOMAIN} {
reverse_proxy authelia:9091
tls {
dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
}
Ajoutez l'enregistrement A suivant à votre domaine DNS :
auth.home.yourdomain.com 192.168.0.4 # replace with your Docker host's IP address
Essayez de résoudre le nom sur une machine de votre réseau (par exemple, nslookup auth.home.yourdomain.com). Si cela échoue, vous devrez peut-être contourner la protection de rebind DNS sur votre routeur .
Demandez à Caddy de recharger sa configuration en exécutant :
docker exec -w /etc/caddy caddy caddy reload
Vous devriez maintenant pouvoir accéder à l'interface Web d'Authelia https://authelia.home.yourdomain.comsans recevoir d'avertissement de certificat de votre navigateur.
Pour protéger un point de terminaison avec l'authentification d'Authelia (et éventuellement activer SSO), ajoutez une forward_authdirective à la configuration Caddy du point de terminaison. La configuration du whoamiconteneur que nous avons utilisé comme exemple dans l' article précédent se présente comme suit avec la forward_authdirective ajoutée :
whoami.{$MY_DOMAIN} {
forward_auth authelia:9091 {
uri /api/verify?rd=https://auth.{$MY_DOMAIN}/
copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
}
reverse_proxy whoami:80
tls {
dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
}
La prise en charge d'Authelia pour OpenID Connect (OIDC) est marquée comme « bêta ». Il n'est pas encore complet en fonctionnalités mais devrait fonctionner assez bien dans la plupart des scénarios. La feuille de route OpenID Connect d'Authelia documente les progrès en détail. La documentation OpenID Connect d'Authelia contient des exemples de configurations pour des services populaires tels que Nextcloud.
Consultez cet article de suivi pour une description détaillée de la façon de configurer l’authentification OpenID Connect sur Authelia dans ownCloud Infinite Scale.